home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 3 / Amiga Tools 3.iso / grafik / raytracing / rayshade-4.0.6.3 / include / rle.h < prev   
C/C++ Source or Header  |  1994-09-15  |  15KB  |  484 lines
  1. /*
  2.  * This software is copyrighted as noted below.  It may be freely copied,
  3.  * modified, and redistributed, provided that the copyright notice is 
  4.  * preserved on all copies.
  5.  * 
  6.  * There is no warranty or other guarantee of fitness for this software,
  7.  * it is provided solely "as is".  Bug reports or fixes may be sent
  8.  * to the author, who may or may not act on them as he desires.
  9.  *
  10.  * You may not include this software in a program or other software product
  11.  * without supplying the source, or without informing the end-user that the 
  12.  * source is available for no extra charge.
  13.  *
  14.  * If you modify this software, you should include a notice giving the
  15.  * name of the person performing the modification, the date of modification,
  16.  * and the reason for such modification.
  17.  */
  18. /* 
  19.  * rle.h - Global declarations for Utah Raster Toolkit RLE programs.
  20.  * 
  21.  * Author:    Todd W. Fuqua
  22.  *         Computer Science Dept.
  23.  *         University of Utah
  24.  * Date:    Sun Jul 29 1984
  25.  * Copyright (c) 1984 Todd W. Fuqua
  26.  * 
  27.  * $Id: rle.h,v 3.0 90/08/03 15:19:43 spencer Exp $
  28.  */
  29.  
  30. #ifndef RLE_H
  31. #define RLE_H
  32.  
  33. #include <stdio.h>        /* Declare FILE. */
  34.  
  35. #ifdef c_plusplus
  36. #define USE_PROTOTYPES
  37. #endif
  38. #ifndef CONST_DECL
  39. #define CONST_DECL
  40. #endif
  41.  
  42. enum rle_dispatch {
  43.     NO_DISPATCH = -1,
  44.     RUN_DISPATCH = 0
  45. };
  46.  
  47. /* ****************************************************************
  48.  * TAG( rle_pixel rle_map )
  49.  *
  50.  * Typedef for 8-bit (or less) pixel data.
  51.  *
  52.  * Typedef for 16-bit color map data.
  53.  */
  54. typedef unsigned char rle_pixel;
  55. typedef unsigned short rle_map;
  56.  
  57. /*
  58.  * Defines for traditional channel numbers.
  59.  */
  60. #define    RLE_RED        0    /* Red channel traditionally here. */
  61. #define RLE_GREEN    1    /* Green channel traditionally here. */
  62. #define    RLE_BLUE    2    /* Blue channel traditionally here. */
  63. #define RLE_ALPHA      -1    /* Alpha channel here. */
  64.  
  65. /*
  66.  * Return values from rle_get_setup.
  67.  */
  68. #define    RLE_SUCCESS     0
  69. #define    RLE_NOT_RLE    -1
  70. #define    RLE_NO_SPACE    -2
  71. #define    RLE_EMPTY    -3
  72. #define    RLE_EOF        -4
  73.  
  74. /*
  75.  * TAG( rle_hdr )
  76.  *
  77.  * Definition of header structure used by RLE routines.
  78.  */
  79.  
  80. #ifndef c_plusplus
  81. typedef struct rle_hdr rle_hdr;
  82. #endif
  83.  
  84. struct rle_hdr {
  85.     enum     rle_dispatch dispatch;    /* Type of file to create. */
  86.     int            ncolors,    /* Number of color channels. */
  87.            *bg_color,    /* Pointer to bg color vector. */
  88.             alpha,        /* If !0, save alpha channel. */
  89.             background,    /* 0->just save all pixels, */
  90.                 /* 1->overlay, 2->clear to bg first. */
  91.             xmin,        /* Lower X bound (left.) */
  92.             xmax,        /* Upper X bound (right.) */
  93.             ymin,        /* Lower Y bound (bottom.) */
  94.             ymax,        /* Upper Y bound (top.) */
  95.             ncmap,        /* Number of color channels in color map. */
  96.                 /* Map only saved if != 0. */
  97.             cmaplen;    /* Log2 of color map length. */
  98.     rle_map    *cmap;        /* Pointer to color map array. */
  99.     CONST_DECL char **comments;    /* Pointer to array of pointers to comments. */
  100.     FILE       *rle_file;    /* Input or output file. */
  101.     /* 
  102.      * Bit map of channels to read/save.  Indexed by (channel mod 256).
  103.      * Alpha channel sets bit 255.
  104.      * 
  105.      * Indexing (0 <= c <= 255):
  106.      *        bits[c/8] & (1 << (c%8))
  107.      */
  108. #define RLE_SET_BIT(glob,bit) \
  109.      ((glob).bits[((bit)&0xff)/8] |= (1<<((bit)&0x7)))
  110. #define RLE_CLR_BIT(glob,bit) \
  111.     ((glob).bits[((bit)&0xff)/8] &= ~(1<<((bit)&0x7)))
  112. #define RLE_BIT(glob,bit) \
  113.     ((glob).bits[((bit)&0xff)/8] & (1<<((bit)&0x7)))
  114.     char    bits[256/8];
  115.     /* 
  116.      * Local storage for rle_getrow & rle_putrow.
  117.      * rle_getrow has
  118.      *        scan_y    int        current Y scanline.
  119.      *        vert_skip    int        number of lines to skip.
  120.      * rle_putrow has
  121.      *        nblank    int        number of blank lines.
  122.      *        brun    short(*)[2] Array of background runs.
  123.      *        fileptr    long        Position in output file.
  124.      */
  125.      union {
  126.     struct {
  127.         int    scan_y,
  128.         vert_skip;
  129.         char is_eof,    /* Set when EOF or EofOp encountered. */
  130.         is_seek;    /* If true, can seek input file. */
  131.     } get;
  132.     struct {
  133.         int    nblank;
  134.         short (*brun)[2];
  135.         long fileptr;
  136.     } put;
  137.      } priv;
  138. };
  139.  
  140. /* 
  141.  * TAG( rle_dflt_hdr )
  142.  *
  143.  * Global variable with possibly useful default values.
  144.  */
  145. extern rle_hdr rle_dflt_hdr;
  146.  
  147.  
  148. /* Declare RLE library routines. */
  149.  
  150. #ifdef USE_PROTOTYPES
  151.     /* From rle_getrow.c */
  152.  
  153.     /*****************************************************************
  154.      * TAG( rle_debug )
  155.      * 
  156.      * Turn RLE debugging on or off.
  157.      */
  158.     extern void rle_debug( int on_off );
  159.  
  160.     /*****************************************************************
  161.      * TAG( rle_get_error )
  162.      *
  163.      * Print an error message based on the error code returned by
  164.      * rle_get_setup.
  165.      */
  166.     extern int rle_get_error( int code,
  167.                   CONST_DECL char *pgmname,
  168.                   CONST_DECL char *fname );
  169.               
  170.     /*****************************************************************
  171.      * TAG( rle_get_setup )
  172.      */
  173.     extern int rle_get_setup( rle_hdr *the_hdr );
  174.  
  175.     /*****************************************************************
  176.      * TAG( rle_get_setup_ok )
  177.      *
  178.      * Call rle_get_setup.  If it returns an error code, call
  179.      * rle_get_error to print the error message, then exit with the error
  180.      * code. 
  181.      */
  182.     extern void rle_get_setup_ok( rle_hdr *the_hdr,
  183.                   CONST_DECL char *prog_name,
  184.                   CONST_DECL char *file_name);
  185.  
  186.     /*****************************************************************
  187.      * TAG( rle_getrow )
  188.      *
  189.      * Read a scanline worth of data from an RLE file.
  190.      */
  191.     extern int rle_getrow( rle_hdr * the_hdr, 
  192.                rle_pixel * scanline[] );
  193.  
  194.     /* From rle_getskip.c */
  195.  
  196.     /*****************************************************************
  197.      * TAG( rle_getskip )
  198.      * Skip a scanline, return the number of the next one.
  199.      */
  200.     extern unsigned int rle_getskip( rle_hdr *the_hdr );
  201.  
  202.     /* From rle_putrow.c. */
  203.  
  204.     /*****************************************************************
  205.      * TAG( rgb_to_bw )
  206.      *
  207.      * Converts RGB data to gray data via the NTSC Y transform.
  208.      */
  209.     extern void rgb_to_bw( rle_pixel *red_row,
  210.                rle_pixel *green_row,
  211.                rle_pixel *blue_row,
  212.                rle_pixel *bw_row,
  213.                int rowlen );
  214.  
  215.     /*****************************************************************
  216.      * TAG( rle_puteof )
  217.      *
  218.      * Write an End-of-image opcode to the RLE file.
  219.      */
  220.     extern void rle_puteof( rle_hdr *the_hdr );
  221.  
  222.     /*****************************************************************
  223.      * TAG( rle_putrow )
  224.      *
  225.      * Write a scanline of data to the RLE file.
  226.      */
  227.     extern void rle_putrow( rle_pixel *rows[], int rowlen, rle_hdr *the_hdr );
  228.  
  229.     /*****************************************************************
  230.      * TAG( rle_put_init )
  231.      *
  232.      * Initialize header for output, but don't write it to the file.
  233.      */
  234.     extern void rle_put_init( rle_hdr * the_hdr );
  235.  
  236.     /*****************************************************************
  237.      * TAG( rle_put_setup )
  238.      *
  239.      * Write header information to a new RLE image file.
  240.      */
  241.     extern void rle_put_setup( rle_hdr * the_hdr );
  242.  
  243.     /*****************************************************************
  244.      * TAG( rle_skiprow )
  245.      *
  246.      * Skip nrow scanlines in the output file.
  247.      */
  248.     extern void rle_skiprow( rle_hdr *the_hdr, int nrow );
  249.  
  250.     /* From rle_cp.c */
  251.     /*****************************************************************
  252.      * TAG( rle_cp )
  253.      * Copy image data from input to output with minimal interpretation.
  254.      */
  255.     extern void rle_cp( rle_hdr *in_hdr, rle_hdr *out_hdr );
  256.  
  257.     /* From rle_row_alc.c. */
  258.     /*****************************************************************
  259.      * TAG( rle_row_alloc )
  260.      *
  261.      * Allocate scanline memory for use by rle_getrow.
  262.      */
  263.     extern int rle_row_alloc( rle_hdr * the_hdr,
  264.                   rle_pixel *** scanp );
  265.  
  266.     /*****************************************************************
  267.      * TAG( rle_row_free )
  268.      *
  269.      * Free the above.
  270.      */
  271.     extern void rle_row_free( rle_hdr *the_hdr, rle_pixel **scanp );
  272.  
  273.     /* From buildmap.c. */
  274.     /* 
  275.      * buildmap - build a more usable colormap from data in the_hdr struct.
  276.      */
  277.     extern rle_pixel **buildmap( rle_hdr *the_hdr,
  278.                  int minmap,
  279.                  double orig_gamma,
  280.                  double new_gamma );
  281.  
  282.     /* From rle_getcom.c. */
  283.     /*****************************************************************
  284.      * TAG( rle_getcom )
  285.      *
  286.      * Get a specific comment from the image comments.
  287.      */
  288.     extern char * rle_getcom( CONST_DECL char * name, rle_hdr * the_hdr );
  289.  
  290.     /* From rle_putcom.c. */
  291.     /*****************************************************************
  292.      * TAG( rle_delcom )
  293.      *
  294.      * Delete a specific comment from the image comments.
  295.      */
  296.     extern CONST_DECL char *
  297.     rle_delcom( CONST_DECL char * name, rle_hdr * the_hdr );
  298.  
  299.     /*****************************************************************
  300.      * TAG( rle_putcom )
  301.      * 
  302.      * Put (or replace) a comment into the image comments.
  303.      */
  304.     extern CONST_DECL char *
  305.     rle_putcom( CONST_DECL char * value, rle_hdr * the_hdr );
  306.  
  307.     /* From dither.c. */
  308.     /*****************************************************************
  309.      * TAG( bwdithermap )
  310.      * Create a color map for ordered dithering in grays.
  311.      */
  312.     extern void bwdithermap( int levels, double gamma, int bwmap[],
  313.                  int divN[256], int modN[256], int magic[16][16] );
  314.     /*****************************************************************
  315.      * TAG( ditherbw )
  316.      * Dither a gray-scale value.
  317.      */
  318.     extern int ditherbw( int x, int y, int val, 
  319.              int divN[256], int modN[256], int magic[16][16] );
  320.     /*****************************************************************
  321.      * TAG( dithergb )
  322.      * Dither a color value.
  323.      */
  324.     extern int dithergb( int x, int y, int r, int g, int b,
  325.              int divN[256], int modN[256], int magic[16][16] );
  326.     /*****************************************************************
  327.      * TAG( dithermap )
  328.      * Create a color map for ordered dithering in color.
  329.      */
  330.     extern void dithermap( int levels, double gamma, int rgbmap[][3],
  331.                int divN[256], int modN[256], int magic[16][16] );
  332.     /*****************************************************************
  333.      * TAG( make_square )
  334.      * Make a 16x16 magic square for ordered dithering.
  335.      */
  336.     extern void make_square( double N, int divN[256], int modN[256],
  337.                  int magic[16][16] );
  338.  
  339.     /* From float_to_exp.c. */
  340.     /*****************************************************************
  341.      * TAG( float_to_exp )
  342.      * Convert a list of floating point numbers to "exp" format.
  343.      */
  344.     extern void float_to_exp( int count, float * floats, rle_pixel * pixels );
  345.  
  346.     /* From rle_open_f.c. */
  347.     /*****************************************************************
  348.      * TAG( rle_open_f )
  349.      *
  350.      * Open an input/output file with default.
  351.      */
  352.     extern FILE *
  353.     rle_open_f( CONST_DECL char *prog_name,
  354.         CONST_DECL char *f_name,
  355.         CONST_DECL char *mode );
  356.  
  357.     /*****************************************************************
  358.      * TAG( rle_open_f_noexit )
  359.      *
  360.      * Open an input/output file with default.
  361.      */
  362.     extern FILE *
  363.     rle_open_f_noexit( CONST_DECL char *prog_name,
  364.                CONST_DECL char *f_name,
  365.                CONST_DECL char *mode );
  366.  
  367.     /* From colorquant.c. */
  368.     /*****************************************************************
  369.      * TAG( colorquant )
  370.      * Compute a colormap for quantizing an image to a limited set of colors.
  371.      */
  372.     extern int colorquant( rle_pixel *red, rle_pixel *green, rle_pixel *blue,
  373.                unsigned long pixels, rle_pixel *colormap[3],
  374.                int colors, int bits,
  375.                          rle_pixel *rgbmap, int fast, int otherimages );
  376.  
  377.     /* From rle_addhist.c. */
  378.     /*****************************************************************
  379.      * TAG( rle_addhist )
  380.      * Append history information to the HISTORY comment.
  381.      */
  382. extern void rle_addhist( char *argv[],
  383.              rle_hdr *in_hdr,
  384.              rle_hdr *out_hdr );
  385.  
  386.     /* From cmd_name.c. */
  387.     /*****************************************************************
  388.      * TAG( cmd_name )
  389.      * Extract command name from argv.
  390.      */
  391.     extern char *cmd_name( char **argv );
  392.  
  393.     /* From scanargs.c. */
  394.     /*****************************************************************
  395.      * TAG( scanargs )
  396.      * Scan command argument list and parse arguments.
  397.      */
  398.     extern int scanargs( int argc,
  399.              char **argv,
  400.              CONST_DECL char *format,
  401.              ... );
  402.  
  403. #ifdef NEED_BSTRING
  404.     /* From bstring.c. */
  405.     /*****************************************************************
  406.      * TAG( bstring bzero )
  407.      * 'Byte string' functions.
  408.      */
  409.     extern void bzero( char *str, int count );
  410.     extern void bcopy( char *from, char *to, int count );
  411. #endif
  412. #else /* USE_PROTOTYPES */
  413.     /* Return value decls for "K&R" C.  See above for full descriptions. */
  414.  
  415.     /* From rle_getrow.c. */
  416.     extern void rle_debug();
  417.     extern int rle_get_error();
  418.     extern int rle_get_setup();
  419.     extern void rle_get_setup_ok();
  420.     extern int rle_getrow();
  421.  
  422.     /* From rle_getskip.c */
  423.     extern unsigned int rle_getskip();
  424.  
  425.     /* From rle_putrow.c. */
  426.     extern void rgb_to_bw();
  427.     extern void rle_puteof();
  428.     extern void rle_putrow();
  429.     extern void rle_put_init();
  430.     extern void rle_put_setup();
  431.     extern void rle_skiprow();
  432.  
  433.     /* From rle_cp.c */
  434.     extern void rle_cp();
  435.  
  436.     /* From rle_row_alc.c. */
  437.     extern int rle_row_alloc();
  438.     extern void rle_row_free();
  439.  
  440.     /* From buildmap.c. */
  441.     extern rle_pixel **buildmap();
  442.     
  443.     /* From rle_getcom.c. */
  444.     extern char *rle_getcom();
  445.  
  446.     /* From rle_putcom.c. */
  447.     extern char *rle_delcom();
  448.     extern char *rle_putcom();
  449.  
  450.     /* From dither.c. */
  451.     extern void bwdithermap();
  452.     extern int ditherbw();
  453.     extern int dithergb();
  454.     extern void dithermap();
  455.     extern void magic4x4();
  456.     extern void make_square();
  457.  
  458.     /* From float_to_exp.c. */
  459.     extern void float_to_exp();
  460.  
  461.     /* From rle_open_f.c. */
  462.     extern FILE *rle_open_f();
  463.     extern FILE *rle_open_f_noexit();
  464.  
  465.     /* From colorquant.c. */
  466.     extern int colorquant();
  467.  
  468.     /* From rle_addhist.c. */
  469.     extern void rle_addhist();
  470.  
  471.     /* From cmd_name.c. */
  472.     extern char *cmd_name();
  473.  
  474.     /* From scanargs.c. */
  475.     extern int scanargs();
  476. #ifdef NEED_BSTRING
  477.     /* From bstring.c. */
  478.     extern void bzero();
  479.     extern void bcopy();
  480. #endif
  481. #endif /* USE_PROTOTYPES */
  482.  
  483. #endif /* RLE_H */
  484.